package com.ep.thirdPlatformProject.oa.util;

import cn.com.weaver.services.webservices.WorkflowServiceHttpBindingStub;
import cn.com.weaver.services.webservices.WorkflowServiceLocator;
import com.ep.thirdPlatformProject.oa.enums.ResultEnum;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.security.AnyTypePermission;
import localhost.services.HrmService.HrmServiceHttpBindingStub;
import localhost.services.HrmService.HrmServiceLocator;
import lombok.extern.slf4j.Slf4j;
//import org.apache.axiom.om.*;
//import org.apache.axiom.soap.SOAP11Constants;
//import org.apache.axis2.addressing.EndpointReference;
//import org.apache.axis2.client.Options;
//import org.apache.axis2.databinding.utils.BeanUtil;
//import org.apache.axis2.rpc.client.RPCServiceClient;
//import weaver.hrm.webservice.JobTitleBean;
//import weaver.workflow.webservices.WorkflowRequestInfo;

import javax.xml.namespace.QName;
import javax.xml.stream.XMLStreamReader;
import java.net.URL;
import java.util.*;
import java.util.stream.Collectors;

@Slf4j
public class Axis2Util {


/*
    */
/**
     * 构建参数并调用指定的服务端点
     * 目前支持map（无外层对象）和普通对象
     *
     * @param object     需要转换为XML格式并发送的服务调用参数
     * @param endpoint   服务的端点地址
     * @param methodName 需要调用的服务方法名
     * @param nameSpace  命名空间
     * @return 调用服务后接收到的响应的字符串表示
     *//*

    public static OMElement sendRequestAndReceived(Object object, String endpoint, String methodName, String nameSpace) {
        try {
            // 创建RPC服务客户端
            RPCServiceClient serviceClient = new RPCServiceClient();

            // 根据提供的端点地址创建端点引用
            EndpointReference er = new EndpointReference(endpoint);
            // 设置服务调用选项
            serviceClient.setOptions(buildOptions(er, nameSpace, methodName));

            // 将简单对象转换为OMElement格式
            List<OMElement> omElement = convertSimpleObjectToOMElement(object, nameSpace);
            // 创建OMFactory和OMNamespace，用于构造请求OMElement
            OMFactory fac = OMAbstractFactory.getOMFactory();

            OMNamespace omNs = fac.createOMNamespace(nameSpace, "");
            // 创建代表方法名的OMElement，并将参数OMElement添加为子元素
            OMElement method = fac.createOMElement(methodName, omNs);
            for (OMElement element : omElement) {
                method.addChild(element);
                log.info("当前element元素为：{}", element);
            }
            method.build();
            // 发送请求并接收响应
            OMElement receive = serviceClient.sendReceive(method);
            // 打印响应信息
            System.out.println(receive);
            // 将响应OMElement转换为字符串并返回
            return receive;
        } catch (Exception e) {
            log.error("请求失败！{}", e.getMessage());
            throw new RuntimeException(e);
        }

    }


    */
/**
     * 将简单对象转换为xml格式的对象
     * 这个方法通过使用给定的简单对象，将其转换为XML格式的OMElement对象。
     * 它首先利用BeanUtil的getPullParser方法从对象生成一个XMLStreamReader，
     * 然后使用这个pullParser创建一个OMXMLParserWrapper对象，
     * 通过这个OMXMLParserWrapper对象可以获取到代表XML文档根元素的OMElement。
     * 最后，将转换后的OMElement对象记录到日志中并返回。
     *
     * @param obj 需要转换为XML格式的对象
     * @return {@link OMElement} 转换后的XML根元素
     *//*

    @SuppressWarnings("unchecked")
    public static List<OMElement> convertSimpleObjectToOMElement(Object obj, String nameSpace) {
        List<OMElement> res = new ArrayList<>();
        if (obj instanceof Map) {
            Map<String, Object> map = (Map<String, Object>) obj;
            OMFactory fac = OMAbstractFactory.getOMFactory();
            OMNamespace omNs = fac.createOMNamespace(nameSpace, "");
            for (String key : map.keySet()) {
                OMElement param = fac.createOMElement(key, omNs);
                if (map.get(key) instanceof String) {
                    param.setText(map.get(key).toString());
                } else {
                    param = convertObjectToOMXML(map.get(key));
                    param.setLocalName("in0");
                }

                res.add(param);
            }

        } else if (obj instanceof List<?>) {
            OMElement param = convertListToOMXML((List<?>) obj);
            res.add(param);
        } else {
            OMElement param = convertObjectToOMXML(obj);
            res.add(param);
        }
        return res;
    }

    public static OMElement convertObjectToOMXML(Object obj) {

        // 使用BeanUtil的工具方法将对象转换为XMLStreamReader
        XMLStreamReader pullParser = BeanUtil.getPullParser(obj);

        // 基于XMLStreamReader创建OMXMLParserWrapper对象，用于构建OMElement
        OMXMLParserWrapper stAXOMBuilder = OMXMLBuilderFactory.createStAXOMBuilder(pullParser);

        // 获取代表XML文档根元素的OMElement
        OMElement param = stAXOMBuilder.getDocumentElement();
        // 将OMElement对象的内容记录到日志中
        log.info(param.toString());
        return param;
    }

    */
/**
     * 将列表转换为omXML元素。
     *
     * @param list 需要转换为omXML的列表，列表中的元素类型由clazz参数指定。
     * @return 转换后的OMElement对象，代表了列表的XML形式。
     *//*

    public static OMElement convertListToOMXML(List<?> list) {
        // 参数校验
        if (list == null) {
            throw new IllegalArgumentException("List and Class cannot be null.");
        }

        // 处理空列表的情况，此处选择返回null，也可以选择抛出异常或其他处理方式
        if (list.isEmpty()) {
            return null; // 或者 throw new IllegalArgumentException("List cannot be empty.");
        }
        // 将列表转换为数组，并通过BeanUtil的getOMElement方法转换为OMXML元素
        return BeanUtil.getOMElement(new QName("root"), list.toArray(), new QName(list.get(0).getClass().getSimpleName().toLowerCase()), false, null);
    }


    */
/**
     * 解析OM元素列表为指定类型的列表。
     *
     * @param element 要解析的OM元素，不可为null。
     * @param clazz   指定的类型，解析的结果将为此类型的列表。
     * @return 返回解析后的类型列表，如果输入元素为null，则返回null。
     * @throws Exception 如果解析过程中发生错误，将抛出异常。
     *//*

    public static <T> List<T> parseListOMElement(OMElement element, Class<T> clazz) throws Exception {
        List<T> list = new ArrayList<>();
        if (element == null) {
            return null;
        }
        Iterator<OMElement> iterator = element.getChildElements();

        // 使用XStream库从OM元素中反序列化对象
        try {
            while (iterator.hasNext()) {
                XStream xstream = new XStream();
                xstream.addPermission(AnyTypePermission.ANY);
                while (iterator.hasNext()) {
                    OMElement omNode = iterator.next();
                    if (omNode.getType() == OMNode.ELEMENT_NODE) {
                        Object object = xstream.fromXML(omNode.getText());
                        List<T> ts = castObjectToList(object, clazz);
                        list.addAll(ts);
                    }
                }

            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        return list;
    }

    @SuppressWarnings("unchecked")
    private static <T> List<T> castObjectToList(Object obj, Class<T> elementType) {
        List<T> list = new ArrayList<>();
        if (obj instanceof List<?> rawList) {
            for (Object item : rawList) {
                if (elementType.isInstance(item)) {
                    list.add((T) item);
                }
            }
        } else {
            throw new RuntimeException("castObjectToList类型转化失败，该对象返回非list类型的值！");
        }
        return list;
    }

    public static String getResponseStr(Object obj) {

        return "";
    }

    public static Options buildOptions(EndpointReference targetAirline, String nameSpace, String method) {
        Options options = new Options();
        options.setSoapVersionURI(SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI);
        options.setAction(nameSpace + method); // 设置调用的命名空间加方法
        options.setTo(targetAirline);
        return options;
    }




    */
/**
     * 提交工作流请求
     *
     * @param workflowRequestInfo 工作流请求信息
     * @param requestId           请求id
     * @param userId              用户id
     * @param type                类型 1
     * @param remark              备注
     * @return {@link String }
     *//*

    public String submitWorkflowRequest(WorkflowRequestInfo workflowRequestInfo, Integer requestId, Integer userId, String type, String remark) {
        try {
            WorkflowServiceLocator service = new WorkflowServiceLocator();

            WorkflowServiceHttpBindingStub stub = new WorkflowServiceHttpBindingStub(new URL("http://10.10.10.20:8181/services/WorkflowService"), service);

            return stub.submitWorkflowRequest(workflowRequestInfo, requestId, userId, type, remark);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new RuntimeException("提交错误：" + e.getMessage(), e);
        }

    }

*/


}
